// DbgVector.h

#ifndef _DbgVector_h_
#define _DbgVector_h_

#if _MSC_VER > 1000
	#pragma once
#endif

#include "nprbase.h"

#if defined(_DEBUG)// && !defined(_NP_IS_VC2008)
	#include "SmartArray.h"
	#include "nplist.h"
	#include "QuickID.h"
	#include "QuickMap.h"

	template<typename TYPE>
	class DbgVector : public CSmartArray<TYPE>
	{
		typedef CSmartArray<TYPE> base_vector;
	public:
		DbgVector() : base_vector()
		{
		}
		~DbgVector()
		{
		}
		DbgVector(const DbgVector& r) : base_vector(r)
		{
		}
		DbgVector& operator = (const DbgVector& r)
		{
			(base_vector&)*this = (const base_vector&)r;
			return *this;
		}
	};
	template<typename TYPE>
	class DbgList : public nplist<TYPE>
	{
		typedef nplist<TYPE> base_list;
	public:
		DbgList() : base_list()
		{
		}
		~DbgList()
		{
		}
		DbgList(const DbgList& r) : base_list(r)
		{
		}
		DbgList& operator = (const DbgList& r)
		{
			(base_list&)*this = (const base_list&)r;
			return *this;
		}
	};
	template<typename TYPE>
	class DbgSet : public CQuickID<TYPE>
	{
		typedef CQuickID<TYPE> base_set;
	public:
		DbgSet() : base_set()
		{
		}
		~DbgSet()
		{
		}
		DbgSet(const DbgSet& r) : base_set(r)
		{
		}
		DbgSet& operator = (const DbgSet& r)
		{
			(base_set&)*this = (const base_set&)r;
			return *this;
		}
	};

	template<typename KEY_TYPE, typename TYPE>
	class DbgMap : public CQuickMap<KEY_TYPE, TYPE>
	{
		typedef CQuickMap<KEY_TYPE, TYPE> base_map;
	public:
		DbgMap() : base_map()
		{
		}
		~DbgMap()
		{
		}
		DbgMap(const DbgMap& r) : base_map(r)
		{
		}
		DbgMap& operator = (const DbgMap& r)
		{
			(base_map&)*this = (const base_map&)r;
			return *this;
		}
	};

#else
	#include <vector>
	#include <list>
	#include "npset.h"
	#include "npmap.h"

	template<typename TYPE>
	struct DbgVector : public std::vector<TYPE, std::allocator<TYPE> > {};

	template<typename TYPE>
	struct DbgList : public std::list<TYPE, std::allocator<TYPE> > {};

	template<typename TYPE>
	struct DbgSet : public npset<TYPE> {};

	template<typename KEY_TYPE, typename TYPE>
	struct DbgMap : public npmap<KEY_TYPE, TYPE> {};
#endif

#endif	// #ifndef _DbgVector_h_
